package com.atguigu.gmall.cart.service.impl;

import com.atguigu.gmall.cart.service.CartService;
import com.atguigu.gmall.common.constant.RedisConst;
import com.atguigu.gmall.common.util.DateUtil;
import com.atguigu.gmall.model.cart.CartInfo;
import com.atguigu.gmall.model.product.SkuInfo;
import com.atguigu.gmall.product.client.ProductFeignClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.BoundHashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import org.springframework.util.StringUtils;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 *
 */
@Service
@SuppressWarnings("all")
public class CartServiceImpl implements CartService {

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private ProductFeignClient productFeignClient;


    /**
     加入购物车 实现思路：

     1、如果第一次加入购物车
     key            skuId    构建cartInfo
     cart:1:info     22       cartInfo
     2、如果第一次加入购物车
     数量相加
     选中状态
     修改时间
     价格更新

     问题：判断如果识别是一次加入购物车？
                先查询，再判断

    */
    @Override
    public void addToCart(String userId, Long skuId, Integer skuNum) {

        //定义key
        String cartKey = RedisConst.USER_KEY_PREFIX+userId+RedisConst.USER_CART_KEY_SUFFIX;
        //尝试获取
        BoundHashOperations<String,String, CartInfo> boundHashOps = redisTemplate.boundHashOps(cartKey);

        CartInfo cartInfo = null;

        //判断
        if (boundHashOps.hasKey(skuId.toString())) {

            //包含
            cartInfo = boundHashOps.get(skuId.toString());
            //修改数量
            cartInfo.setSkuNum(cartInfo.getSkuNum()+skuNum);
            cartInfo.setIsChecked(1);
            cartInfo.setSkuPrice(productFeignClient.getSkuPrice(skuId));
            cartInfo.setUpdateTime(new Date());

        }else {

            //获取skuInfo信息
            SkuInfo skuInfo = productFeignClient.getSkuInfo(skuId);
            //不包含
            cartInfo = new CartInfo();
            cartInfo.setUserId(userId);
            cartInfo.setSkuId(skuId);
            cartInfo.setCartPrice(skuInfo.getPrice());
            cartInfo.setSkuName(skuInfo.getSkuName());
            cartInfo.setSkuNum(skuNum);
            cartInfo.setImgUrl(skuInfo.getSkuDefaultImg());
            cartInfo.setIsChecked(1);
            cartInfo.setCreateTime(new Date());
            cartInfo.setUpdateTime(new Date());
            cartInfo.setSkuPrice(skuInfo.getPrice());
        }

        //保存redis
        boundHashOps.put(skuId.toString(),cartInfo);

    }

    /**
     获取选中状态的购物车列表

    */
    @Override
    public List<CartInfo> getCartCheckedList(String userId) {

        List<CartInfo> cartInfoList=null;

        //获取key
        String cartKey = getCartKey(userId);

        //获取所有购物车
        cartInfoList = redisTemplate.boundHashOps(cartKey).values();

        //判断是否选中
        //判断不为null
        if (!CollectionUtils.isEmpty(cartInfoList)) {
            cartInfoList.stream().filter(cartInfo -> {

                //更新价格
                cartInfo.setSkuPrice(productFeignClient.getSkuPrice(cartInfo.getSkuId()));

                return cartInfo.getIsChecked().intValue() == 1;
            }).collect(Collectors.toList());
        }


        return cartInfoList;
    }

    /**
     删除购物车
     接口路径：DELETE/api/cart/deleteCart/{skuId}

    */
    @Override
    public void deleteCart(String userId, String skuId) {

        //获取key
        String cartKey = getCartKey(userId);
        //获取操作对象
        redisTemplate.boundHashOps(cartKey).delete(skuId);
    }

    /**
     更新选中状态

    */
    @Override
    public void checkCart(String userId, Long skuId, Integer isChecked) {

        //获取key
        String cartKey = getCartKey(userId);
        //获取数据
        BoundHashOperations<String,String,CartInfo> boundHashOps = redisTemplate.boundHashOps(cartKey);
        CartInfo cartInfo = boundHashOps.get(skuId.toString());

        //修改
        //判断
        if (cartInfo != null) {
            cartInfo.setIsChecked(isChecked);
        }

        //保存
        boundHashOps.put(skuId.toString(),cartInfo);

    }

    /**
     获取购物车列表-合并购物车

    */
    @Override
    public List<CartInfo> cartList(String userId, String userTempId) {
        //定义未登陆的购物车
        List<CartInfo> noLoginCartInfoList = null;

        //获取临时购物车
        if (!StringUtils.isEmpty(userTempId)) {
            String cartKey = getCartKey(userTempId);
            //获取列表
            noLoginCartInfoList = redisTemplate.boundHashOps(cartKey).values();
        }

        //用户未登陆
        if (StringUtils.isEmpty(userId)) {

            //判断
            if (!CollectionUtils.isEmpty(noLoginCartInfoList)) {

                noLoginCartInfoList.sort((o1, o2) -> {

                    return DateUtil.truncatedCompareTo(o2.getUpdateTime(),o1.getUpdateTime(), Calendar.SECOND);
                });

                return noLoginCartInfoList;
            }


        }

        //获取登陆后的购物车
        String cartKey = getCartKey(userId);
        BoundHashOperations<String,String,CartInfo> boundHashOps = redisTemplate.boundHashOps(cartKey);

        //判断
        if (!CollectionUtils.isEmpty(noLoginCartInfoList)) {

            //遍历处理
            for (CartInfo noLoginCartInfo : noLoginCartInfoList) {
                //判断是否包含
                if (boundHashOps.hasKey(noLoginCartInfo.getSkuId().toString())) {
                    //包含
                    CartInfo cartInfo = boundHashOps.get(noLoginCartInfo.getSkuId().toString());
                    //数量
                    cartInfo.setSkuNum(noLoginCartInfo.getSkuNum()+cartInfo.getSkuNum());
                    //时间
                    cartInfo.setUpdateTime(new Date());
                    //价格
                    cartInfo.setSkuPrice(productFeignClient.getSkuPrice(cartInfo.getSkuId()));
                    //选中情况
                    if (noLoginCartInfo.getIsChecked().intValue()==1) {

                        cartInfo.setIsChecked(1);
                    }

                    boundHashOps.put(cartInfo.getSkuId().toString(),cartInfo);
                }else {

                    //不包含

                    //userId
                    noLoginCartInfo.setUserId(userId);
                    //时间
                    noLoginCartInfo.setUpdateTime(new Date());
                    //更新
                    noLoginCartInfo.setSkuPrice(productFeignClient.getSkuPrice(noLoginCartInfo.getSkuId()));

                    boundHashOps.put(noLoginCartInfo.getSkuId().toString(),noLoginCartInfo);
                }
            }

            //删除临时购物车
            redisTemplate.delete(getCartKey(userTempId));
        }

        //获取合并过的数据
        List<CartInfo> cartInfoList = boundHashOps.values();

        //判断
        if (CollectionUtils.isEmpty(cartInfoList)) {

            cartInfoList= new ArrayList<>();

        }
        //排序
        cartInfoList.sort((o1, o2) -> {

            return DateUtil.truncatedCompareTo(o2.getUpdateTime(),o1.getUpdateTime(),Calendar.SECOND);
        });

        return cartInfoList;

    }

    /**
     获取购物车的key

    */
    private String getCartKey(String userId) {

        return RedisConst.USER_KEY_PREFIX+userId+RedisConst.USER_CART_KEY_SUFFIX;

    }
}
